﻿using System;
using Microsoft.Win32;
using System.Diagnostics;

namespace Util.Common
{
        #region 1.注册表基项静态域
        /// <summary>              
        /// 注册表基项静态域              
        ///                
        /// 主要包括：              
        /// 1.Registry.ClassesRoot 对应于HKEY_CLASSES_ROOT主键             
        /// 2.Registry.CurrentUser 对应于HKEY_CURRENT_USER主键             
        /// 3.Registry.LocalMachine 对应于 HKEY_LOCAL_MACHINE主键            
        /// 4.Registry.User 对应于 HKEY_USER主键            
        /// 5.Registry.CurrentConfig 对应于HEKY_CURRENT_CONFIG主键             
        /// 6.Registry.DynDa 对应于HKEY_DYN_DATA主键              
        /// 7.Registry.PerformanceData 对应于HKEY_PERFORMANCE_DATA主键              
        ///                
        /// 版本:1.0               
        /// </summary>               
        public enum RegDomain
        {                
             /// <summary>               
             /// 对应于HKEY_CLASSES_ROOT主键               
             /// </summary>               
             ClassesRoot = 0,
             /// <summary>               
             /// 对应于HKEY_CURRENT_USER主键               
             /// </summary>               
             CurrentUser = 1, 
             /// <summary>               
             /// 对应于 HKEY_LOCAL_MACHINE主键              
             /// </summary>               
             LocalMachine = 2, 
             /// <summary>               
             /// 对应于 HKEY_USERS主键              
             /// </summary>               
             User = 3, 
             /// <summary>               
             /// 对应于HEKY_CURRENT_CONFIG主键               
             /// </summary>               
             CurrentConfig = 4, 
             /// <summary>               
             /// 对应于HKEY_DYN_DATA主键               
             /// </summary>               
             DynDa = 5, 
             /// <summary>               
             /// 对应于HKEY_PERFORMANCE_DATA主键               
             /// </summary>               
             PerformanceData = 6, 
        }                
        #endregion
                
        #region 2.指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型                
                 
        /// <summary>              
        /// 指定在注册表中存储值时所用的数据类型，或标识注册表中某个值的数据类型              
        ///               
        /// 主要包括：              
        /// 1.RegistryValueKind.Unknown              
        /// 2.RegistryValueKind.String              
        /// 3.RegistryValueKind.ExpandString              
        /// 4.RegistryValueKind.Binary              
        /// 5.RegistryValueKind.DWord              
        /// 6.RegistryValueKind.MultiString               
        /// 7.RegistryValueKind.QWord               
        ///                
        /// 版本:1.0               
        /// </summary>               
         public enum RegValueKind              
         {                
             /// <summary>               
             /// 指示一个不受支持的注册表数据类型。例如，不支持 Microsoft Win32 API 注册表数据类型 REG_RESOURCE_LIST。使用此值指定          
             /// </summary>               
             Unknown = 0, 
             /// <summary>               
             /// 指定一个以 Null 结尾的字符串。此值与 Win32 API 注册表数据类型 REG_SZ 等效。        
             /// </summary>               
             String = 1, 
             /// <summary>               
             /// 指定一个以 NULL 结尾的字符串，该字符串中包含对环境变量（如 %PATH%，当值被检索时，就会展开）的未展开的引用。            
             /// 此值与 Win32 API注册表数据类型 REG_EXPAND_SZ 等效。           
             /// </summary>               
             ExpandString = 2, 
             /// <summary>               
             /// 指定任意格式的二进制数据。此值与 Win32 API 注册表数据类型 REG_BINARY 等效。          
             /// </summary>               
             Binary = 3, 
             /// <summary>               
             /// 指定一个 32 位二进制数。此值与 Win32 API 注册表数据类型 REG_DWORD 等效。        
             /// </summary>               
             DWord = 4, 
             /// <summary>               
             /// 指定一个以 NULL 结尾的字符串数组，以两个空字符结束。此值与 Win32 API 注册表数据类型 REG_MULTI_SZ 等效。        
             /// </summary>               
             MultiString = 5, 
             /// <summary>               
             /// 指定一个 64 位二进制数。此值与 Win32 API 注册表数据类型 REG_QWORD 等效。        
             /// </summary>               
             QWord = 6, 
         }                
         #endregion               
 
        #region 3.注册表操作工具类
        /// <summary>
         /// 注册表操作工具类
        /// </summary>
        /// 
        public static class UtilRegedit
        {
            /// <summary>
            /// 创建注册表键值
            /// </summary>
            /// <example>
            /// HKEY_CURRENT_USER\SOFTWARE\XibenCallcenter\core\AppPath
            /// </example>
            /// <param name="path">Registry Path路径</param>
            /// <param name="value">值</param>
            /// <returns></returns>
            public static void createKey(string PathKey, string value)
            {
                if (!string.IsNullOrEmpty(PathKey) && PathKey.Contains("\\"))
                {
                    string[] PathFragments = PathKey.Split('\\');
                    string rootPath = PathFragments[0];
                    string Path = "";
                    for (int i = 1; i < PathFragments.Length - 1; i++)
                    {
                        Path += PathFragments[i];
                        if (i < PathFragments.Length - 2)
                        {
                            Path += "\\";
                        }
                    }
                    string key = PathFragments[PathFragments.Length - 1];

                    RegistryBase reg = new RegistryBase(Path, Root(rootPath));
                    reg.RegeditKey = key;
                    reg.WriteRegeditKey(value);
                    
                    //RegistryKey registryKey = Root(rootPath).CreateSubKey(Path);
                    //registryKey.SetValue(key, value);
                    //registryKey.Close();
                }
            }

            /// <summary>
            /// 根据RootPath创建对应的根RegistryKey
            /// </summary>
            /// <param name="RootPath"></param>
            public static RegDomain Root(string RootPath)
            {
                if (RootPath == "HKEY_CURRENT_USER")
                {
                    return RegDomain.CurrentUser;
                }
                else if (RootPath == "HKEY_CLASSES_ROOT")
                {
                    return RegDomain.ClassesRoot;
                }
                else if (RootPath == "HKEY_LOCAL_MACHINE")
                {
                    return RegDomain.LocalMachine;
                }
                else if (RootPath == "HKEY_USERS")
                {
                    return RegDomain.User;
                }
                else if (RootPath == "HEKY_CURRENT_CONFIG")
                {
                    return RegDomain.CurrentConfig;
                }
                else if (RootPath == "HKEY_PERFORMANCE_DATA")
                {
                    return RegDomain.PerformanceData;
                }
                //else if (RootPath == "HKEY_DYN_DATA")
                //{
                //    return Registry.DynData;
                //}
                return RegDomain.CurrentUser;
            }
   
        }
        #endregion

        #region 4.注册表操作基类
        /// <summary>  
        /// 注册表操作基类 
        /// 主要包括以下操作：              
        /// 1.创建注册表项              
        /// 2.读取注册表项              
        /// 3.判断注册表项是否存在              
        /// 4.删除注册表项              
        /// 5.创建注册表键值              
        /// 6.读取注册表键值              
        /// 7.判断注册表键值是否存在              
        /// 8.删除注册表键值              
        ///               
        /// 版本:1.0              
        /// </summary>
        /// C#注册表操作类（完整版）
        /// <see cref="http://www.7747.net/kf/201007/52894.html"/>
         public class RegistryBase
         {
             #region 字段定义
             /// <summary>              
             /// 注册表项名称              
             /// </summary>              
             private string _subkey;
             /// <summary>              
             /// 注册表基项域              
             /// </summary>              
             private RegDomain _domain;
             /// <summary>              
             /// 注册表键值              
             /// </summary>              
             private string _regeditkey;
             #endregion

             #region 属性
             /// <summary>              
             /// 设置注册表项名称              
             /// </summary>              
             public string SubKey
             {
                 //get { return _subkey; }           
                 set { _subkey = value; }
             }

             /// <summary>              
             /// 注册表基项域              
             /// </summary>              
             public RegDomain Domain
             {
                 ///get { return _domain; }           
                 set { _domain = value; }
             }

             /// <summary>              
             /// 注册表键值              
             /// </summary>              
             public string RegeditKey
             {
                 ///get{return _regeditkey;}              
                 set { _regeditkey = value; }
             }
             #endregion

             #region 构造函数
             public RegistryBase()
             {
                 ///默认注册表项名称               
                 _subkey = "software\\";
                 ///默认注册表基项域               
                 _domain = RegDomain.LocalMachine;
             }

             /// <summary>              
             /// 构造函数              
             /// </summary>              
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             public RegistryBase(string subKey, RegDomain regDomain)
             {
                 ///设置注册表项名称               
                 _subkey = subKey;
                 ///设置注册表基项域               
                 _domain = regDomain;
             }
             #endregion

             #region 受保护方法
             /// <summary>               
             /// 获取注册表基项域对应顶级节点               
             /// 例子：如regDomain是ClassesRoot，则返回Registry.ClassesRoot               
             /// </summary>               
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>注册表基项域对应顶级节点</returns>               
             protected RegistryKey GetRegDomain(RegDomain regDomain)
             {
                 ///创建基于注册表基项的节点                
                 RegistryKey key;

                 #region 判断注册表基项域
                 switch (regDomain)
                 {
                     case RegDomain.ClassesRoot:
                         key = Registry.ClassesRoot; 
                         break;
                     case RegDomain.CurrentUser:
                         key = Registry.CurrentUser; 
                         break;
                     case RegDomain.LocalMachine:
                         key = Registry.LocalMachine; 
                         break;
                     case RegDomain.User:
                         key = Registry.Users; 
                         break;
                     case RegDomain.CurrentConfig:
                         key = Registry.CurrentConfig; 
                         break;
                     //case RegDomain.DynDa:
                     //    key = Registry.DynData; break;
                     case RegDomain.PerformanceData:
                         key = Registry.PerformanceData; 
                         break;
                     default:
                         key = Registry.LocalMachine; 
                         break;
                 }
                 #endregion
                 return key;
             }

             /// <summary>               
             /// 获取在注册表中对应的值数据类型               
             /// 例子：如regValueKind是DWord，则返回RegistryValueKind.DWord               
             /// </summary>               
             /// <param name=""regValueKind"">注册表数据类型</param> 
             /// <returns>注册表中对应的数据类型</returns>               
             protected RegistryValueKind GetRegValueKind(RegValueKind regValueKind)
             {
                 RegistryValueKind regValueK;

                 #region 判断注册表数据类型
                 switch (regValueKind)
                 {
                     case RegValueKind.Unknown:
                         regValueK = RegistryValueKind.Unknown; break;
                     case RegValueKind.String:
                         regValueK = RegistryValueKind.String; break;
                     case RegValueKind.ExpandString:
                         regValueK = RegistryValueKind.ExpandString; break;
                     case RegValueKind.Binary:
                         regValueK = RegistryValueKind.Binary; break;
                     case RegValueKind.DWord:
                         regValueK = RegistryValueKind.DWord; break;
                     case RegValueKind.MultiString:
                         regValueK = RegistryValueKind.MultiString; break;
                     case RegValueKind.QWord:
                         regValueK = RegistryValueKind.QWord; break;
                     default:
                         regValueK = RegistryValueKind.String; break;
                 }
                 #endregion
                 return regValueK;
             }

             #region 打开注册表项
             /// <summary>               
             /// 打开注册表项节点，以只读方式检索子项               
             /// 虚方法，子类可进行重写               
             /// </summary>               
             /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>               
             protected virtual RegistryKey OpenSubKey()
             {
                 ///判断注册表项名称是否为空                
                 if (_subkey == string.Empty || _subkey == null)
                 {
                     return null;
                 }

                 ///创建基于注册表基项的节点                
                 RegistryKey key = GetRegDomain(_domain);

                 ///要打开的注册表项的节点                
                 RegistryKey sKey = null;
                 ///打开注册表项                
                 sKey = key.OpenSubKey(_subkey);
                 ///关闭对注册表项的更改                
                 key.Close();
                 ///返回注册表节点                
                 return sKey;
             }

             /// <summary>               
             /// 打开注册表项节点               
             /// 虚方法，子类可进行重写               
             /// </summary>               
             /// <param name=""writable"">如果需要项的写访问权限，则设置为 true</param> 
             /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>               
             protected virtual RegistryKey OpenSubKey(bool writable)
             {
                 ///判断注册表项名称是否为空                
                 if (_subkey == string.Empty || _subkey == null)
                 {
                     return null;
                 }

                 ///创建基于注册表基项的节点                
                 RegistryKey key = GetRegDomain(_domain);

                 ///要打开的注册表项的节点                
                 RegistryKey sKey = null;
                 ///打开注册表项                
                 sKey = key.OpenSubKey(_subkey, writable);
                 ///关闭对注册表项的更改                
                 key.Close();
                 ///返回注册表节点                
                 return sKey;
             }

             /// <summary>               
             /// 打开注册表项节点，以只读方式检索子项               
             /// 虚方法，子类可进行重写               
             /// </summary>               
             /// <param name=""subKey"">注册表项名称</param> 
             /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>               
             protected virtual RegistryKey OpenSubKey(string subKey)
             {
                 ///判断注册表项名称是否为空                
                 if (subKey == string.Empty || subKey == null)
                 {
                     return null;
                 }

                 ///创建基于注册表基项的节点                
                 RegistryKey key = GetRegDomain(_domain);

                 ///要打开的注册表项的节点                
                 RegistryKey sKey = null;
                 ///打开注册表项                
                 sKey = key.OpenSubKey(subKey);
                 ///关闭对注册表项的更改                
                 key.Close();
                 ///返回注册表节点                
                 return sKey;
             }

             /// <summary>               
             /// 打开注册表项节点，以只读方式检索子项               
             /// 虚方法，子类可进行重写               
             /// </summary>               
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""writable"">如果需要项的写访问权限，则设置为 true</param> 
             /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>               
             protected virtual RegistryKey OpenSubKey(string subKey, bool writable)
             {
                 ///判断注册表项名称是否为空                
                 if (subKey == string.Empty || subKey == null)
                 {
                     return null;
                 }

                 ///创建基于注册表基项的节点                
                 RegistryKey key = GetRegDomain(_domain);

                 ///要打开的注册表项的节点                
                 RegistryKey sKey = null;
                 ///打开注册表项                
                 sKey = key.OpenSubKey(subKey, writable);
                 ///关闭对注册表项的更改                
                 key.Close();
                 ///返回注册表节点                
                 return sKey;
             }

             /// <summary>               
             /// 打开注册表项节点，以只读方式检索子项               
             /// 虚方法，子类可进行重写               
             /// </summary>               
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>               
             protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain)
             {
                 ///判断注册表项名称是否为空                
                 if (subKey == string.Empty || subKey == null)
                 {
                     return null;
                 }

                 ///创建基于注册表基项的节点                
                 RegistryKey key = GetRegDomain(regDomain);

                 ///要打开的注册表项的节点                
                 RegistryKey sKey = null;
                 ///打开注册表项                
                 sKey = key.OpenSubKey(subKey);
                 ///关闭对注册表项的更改                
                 key.Close();
                 ///返回注册表节点                
                 return sKey;
             }

             /// <summary>               
             /// 打开注册表项节点               
             /// 虚方法，子类可进行重写               
             /// </summary>               
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <param name=""writable"">如果需要项的写访问权限，则设置为 true</param> 
             /// <returns>如果SubKey为空、null或者SubKey指示注册表项不存在，则返回null，否则返回注册表节点</returns>               
             protected virtual RegistryKey OpenSubKey(string subKey, RegDomain regDomain, bool writable)
             {
                 ///判断注册表项名称是否为空                
                 if (subKey == string.Empty || subKey == null)
                 {
                     return null;
                 }

                 ///创建基于注册表基项的节点                
                 RegistryKey key = GetRegDomain(regDomain);

                 ///要打开的注册表项的节点                
                 RegistryKey sKey = null;
                 ///打开注册表项                
                 sKey = key.OpenSubKey(subKey, writable);
                 ///关闭对注册表项的更改                
                 key.Close();
                 ///返回注册表节点                
                 return sKey;
             }
             #endregion
             #endregion
             
             #region 公有方法
             #region 创建注册表项
             /// <summary>              
             /// 创建注册表项，默认创建在注册表基项 HKEY_LOCAL_MACHINE下面（请先设置SubKey属性）             
             /// 虚方法，子类可进行重写              
             /// </summary>              
             public virtual void CreateSubKey()
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (_subkey == string.Empty || _subkey == null)
                 {
                     return;
                 }

                 ///创建基于注册表基项的节点               
                 RegistryKey key = GetRegDomain(_domain);

                 ///要创建的注册表项的节点               
                 RegistryKey sKey;
                 if (!IsSubKeyExist())
                 {
                     sKey = key.CreateSubKey(_subkey);
                 }
                 //sKey.Close();               
                 ///关闭对注册表项的更改               
                 key.Close();
             }

             /// <summary>              
             /// 创建注册表项，默认创建在注册表基项 HKEY_LOCAL_MACHINE下面             
             /// 虚方法，子类可进行重写              
             /// 例子：如subkey是software\\higame\\，则将创建HKEY_LOCAL_MACHINE\\software\\higame\\注册表项              
             /// </summary>              
             /// <param name=""subKey"">注册表项名称</param> 
             public virtual void CreateSubKey(string subKey)
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (subKey == string.Empty || subKey == null)
                 {
                     return;
                 }

                 ///创建基于注册表基项的节点               
                 RegistryKey key = GetRegDomain(_domain);

                 ///要创建的注册表项的节点               
                 RegistryKey sKey;
                 if (!IsSubKeyExist(subKey))
                 {
                     sKey = key.CreateSubKey(subKey);
                 }
                 //sKey.Close();               
                 ///关闭对注册表项的更改               
                 key.Close();
             }

             /// <summary>              
             /// 创建注册表项，默认创建在注册表基项 HKEY_LOCAL_MACHINE下面             
             /// 虚方法，子类可进行重写              
             /// </summary>              
             /// <param name=""regDomain"">注册表基项域</param> 
             public virtual void CreateSubKey(RegDomain regDomain)
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (_subkey == string.Empty || _subkey == null)
                 {
                     return;
                 }

                 ///创建基于注册表基项的节点               
                 RegistryKey key = GetRegDomain(regDomain);

                 ///要创建的注册表项的节点               
                 RegistryKey sKey;
                 if (!IsSubKeyExist(regDomain))
                 {
                     sKey = key.CreateSubKey(_subkey);
                 }
                 //sKey.Close();               
                 ///关闭对注册表项的更改               
                 key.Close();
             }

             /// <summary>              
             /// 创建注册表项（请先设置SubKey属性）              
             /// 虚方法，子类可进行重写              
             /// 例子：如regDomain是HKEY_LOCAL_MACHINE，subkey是software\\higame\\，则将创建HKEY_LOCAL_MACHINE\\software\\higame\\注册表项              
             /// </summary>              
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             public virtual void CreateSubKey(string subKey, RegDomain regDomain)
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (subKey == string.Empty || subKey == null)
                 {
                     return;
                 }

                 ///创建基于注册表基项的节点               
                 RegistryKey key = GetRegDomain(regDomain);

                 ///要创建的注册表项的节点               
                 RegistryKey sKey;
                 if (!IsSubKeyExist(subKey, regDomain))
                 {
                     sKey = key.CreateSubKey(subKey);
                 }
                 //sKey.Close();               
                 ///关闭对注册表项的更改               
                 key.Close();
             }
             #endregion

             #region 判断注册表项是否存在
             /// <summary>              
             /// 判断注册表项是否存在，默认是在注册表基项HKEY_LOCAL_MACHINE下判断（请先设置SubKey属性）              
             /// 虚方法，子类可进行重写              
             /// 例子：如果设置了Domain和SubKey属性，则判断Domain\\SubKey，否则默认判断HKEY_LOCAL_MACHINE\\software\\              
             /// </summary>              
             /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsSubKeyExist()
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (_subkey == string.Empty || _subkey == null)
                 {
                     return false;
                 }

                 ///检索注册表子项               
                 ///如果sKey为null,说明没有该注册表项不存在，否则存在  
                 RegistryKey sKey = OpenSubKey(_subkey, _domain);
                 if (sKey == null)
                 {
                     return false;
                 }
                 return true;
             }

             /// <summary>              
             /// 判断注册表项是否存在，默认是在注册表基项HKEY_LOCAL_MACHINE下判断              
             /// 虚方法，子类可进行重写              
             /// 例子：如subkey是software\\higame\\，则将判断HKEY_LOCAL_MACHINE\\software\\higame\\注册表项是否存在              
             /// </summary>              
             /// <param name=""subKey"">注册表项名称</param> 
             /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsSubKeyExist(string subKey)
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (subKey == string.Empty || subKey == null)
                 {
                     return false;
                 }

                 ///检索注册表子项               
                 ///如果sKey为null,说明没有该注册表项不存在，否则存在  
                 RegistryKey sKey = OpenSubKey(subKey);
                 if (sKey == null)
                 {
                     return false;
                 }
                 return true;
             }

             /// <summary>              
             /// 判断注册表项是否存在              
             /// 虚方法，子类可进行重写              
             /// 例子：如regDomain是HKEY_CLASSES_ROOT，则将判断HKEY_CLASSES_ROOT\\SubKey注册表项是否存在              
             /// </summary>              
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsSubKeyExist(RegDomain regDomain)
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (_subkey == string.Empty || _subkey == null)
                 {
                     return false;
                 }

                 ///检索注册表子项               
                 ///如果sKey为null,说明没有该注册表项不存在，否则存在  
                 RegistryKey sKey = OpenSubKey(_subkey, regDomain);
                 if (sKey == null)
                 {
                     return false;
                 }
                 return true;
             }

             /// <summary>              
             /// 判断注册表项是否存在（请先设置SubKey属性）              
             /// 虚方法，子类可进行重写              
             /// 例子：如regDomain是HKEY_CLASSES_ROOT，subkey是software\\higame\\，则将判断HKEY_CLASSES_ROOT\\software\\higame\\注册表项是否存在              
             /// </summary>              
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>返回注册表项是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsSubKeyExist(string subKey, RegDomain regDomain)
             {
                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (subKey == string.Empty || subKey == null)
                 {
                     return false;
                 }

                 ///检索注册表子项               
                 ///如果sKey为null,说明没有该注册表项不存在，否则存在  
                 RegistryKey sKey = OpenSubKey(subKey, regDomain);
                 if (sKey == null)
                 {
                     return false;
                 }
                 return true;
             }
             #endregion

             #region 删除注册表项
             /// <summary>              
             /// 删除注册表项（请先设置SubKey属性）              
             /// 虚方法，子类可进行重写              
             /// </summary>              
             /// <returns>如果删除成功，则返回true，否则为false</returns>              
             public virtual bool DeleteSubKey()
             {
                 ///返回删除是否成功               
                 bool result = false;

                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (_subkey == string.Empty || _subkey == null)
                 {
                     return false;
                 }

                 ///创建基于注册表基项的节点               
                 RegistryKey key = GetRegDomain(_domain);

                 if (IsSubKeyExist())
                 {
                     try
                     {
                         ///删除注册表项               
                         key.DeleteSubKey(_subkey);
                         result = true;
                     }
                     catch
                     {
                         result = false;
                     }
                 }
                 ///关闭对注册表项的更改               
                 key.Close();
                 return result;
             }

             /// <summary>              
             /// 删除注册表项（请先设置SubKey属性）              
             /// 虚方法，子类可进行重写              
             /// </summary>              
             /// <param name=""subKey"">注册表项名称</param> 
             /// <returns>如果删除成功，则返回true，否则为false</returns>              
             public virtual bool DeleteSubKey(string subKey)
             {
                 ///返回删除是否成功               
                 bool result = false;

                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (subKey == string.Empty || subKey == null)
                 {
                     return false;
                 }

                 ///创建基于注册表基项的节点               
                 RegistryKey key = GetRegDomain(_domain);

                 if (IsSubKeyExist())
                 {
                     try
                     {
                         ///删除注册表项               
                         key.DeleteSubKey(subKey);
                         result = true;
                     }
                     catch
                     {
                         result = false;
                     }
                 }
                 ///关闭对注册表项的更改               
                 key.Close();
                 return result;
             }

             /// <summary>              
             /// 删除注册表项              
             /// 虚方法，子类可进行重写              
             /// </summary>              
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>如果删除成功，则返回true，否则为false</returns>              
             public virtual bool DeleteSubKey(string subKey, RegDomain regDomain)
             {
                 ///返回删除是否成功               
                 bool result = false;

                 ///判断注册表项名称是否为空，如果为空，返回false               
                 if (subKey == string.Empty || subKey == null)
                 {
                     return false;
                 }

                 ///创建基于注册表基项的节点               
                 RegistryKey key = GetRegDomain(regDomain);

                 if (IsSubKeyExist(subKey, regDomain))
                 {
                     try
                     {
                         ///删除注册表项               
                         key.DeleteSubKey(subKey);
                         result = true;
                     }
                     catch
                     {
                         result = false;
                     }
                 }
                 ///关闭对注册表项的更改               
                 key.Close();
                 return result;
             }
             #endregion

             #region 判断键值是否存在
             /// <summary>              
             /// 判断键值是否存在（请先设置SubKey和RegeditKey属性）              
             /// 虚方法，子类可进行重写              
             /// 1.如果RegeditKey为空、null，则返回false              
             /// 2.如果SubKey为空、null或者SubKey指定的注册表项不存在，返回false              
             /// </summary>              
             /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsRegeditKeyExist()
             {
                 ///返回结果               
                 bool result = false;

                 ///判断是否设置键值属性               
                 if (_regeditkey == string.Empty || _regeditkey == null)
                 {
                     return false;
                 }

                 ///判断注册表项是否存在               
                 if (IsSubKeyExist())
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey();
                     ///键值集合               
                     string[] regeditKeyNames;
                     ///获取键值集合               
                     regeditKeyNames = key.GetValueNames();
                     ///遍历键值集合，如果存在键值，则退出遍历               
                     foreach (string regeditKey in regeditKeyNames)
                     {
                         if (string.Compare(regeditKey, _regeditkey, true) == 0)
                         {
                             result = true;
                             break;
                         }
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return result;
             }

             /// <summary>              
             /// 判断键值是否存在（请先设置SubKey属性）              
             /// 虚方法，子类可进行重写              
             /// 如果SubKey为空、null或者SubKey指定的注册表项不存在，返回false              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsRegeditKeyExist(string name)
             {
                 ///返回结果               
                 bool result = false;

                 ///判断是否设置键值属性               
                 if (name == string.Empty || name == null)
                 {
                     return false;
                 }

                 ///判断注册表项是否存在               
                 if (IsSubKeyExist())
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey();
                     ///键值集合               
                     string[] regeditKeyNames;
                     ///获取键值集合               
                     regeditKeyNames = key.GetValueNames();
                     ///遍历键值集合，如果存在键值，则退出遍历               
                     foreach (string regeditKey in regeditKeyNames)
                     {
                         if (string.Compare(regeditKey, name, true) == 0)
                         {
                             result = true;
                             break;
                         }
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return result;
             }

             /// <summary>              
             /// 判断键值是否存在              
             /// 虚方法，子类可进行重写              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <param name=""subKey"">注册表项名称</param> 
             /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsRegeditKeyExist(string name, string subKey)
             {
                 ///返回结果               
                 bool result = false;

                 ///判断是否设置键值属性               
                 if (name == string.Empty || name == null)
                 {
                     return false;
                 }

                 ///判断注册表项是否存在               
                 if (IsSubKeyExist())
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey(subKey);
                     ///键值集合               
                     string[] regeditKeyNames;
                     ///获取键值集合               
                     regeditKeyNames = key.GetValueNames();
                     ///遍历键值集合，如果存在键值，则退出遍历               
                     foreach (string regeditKey in regeditKeyNames)
                     {
                         if (string.Compare(regeditKey, name, true) == 0)
                         {
                             result = true;
                             break;
                         }
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return result;
             }

             /// <summary>              
             /// 判断键值是否存在              
             /// 虚方法，子类可进行重写              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>返回键值是否存在，存在返回true，否则返回false</returns>              
             public virtual bool IsRegeditKeyExist(string name, string subKey, RegDomain regDomain)
             {
                 ///返回结果               
                 bool result = false;

                 ///判断是否设置键值属性               
                 if (name == string.Empty || name == null)
                 {
                     return false;
                 }

                 ///判断注册表项是否存在               
                 if (IsSubKeyExist())
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey(subKey, regDomain);
                     ///键值集合               
                     string[] regeditKeyNames;
                     ///获取键值集合               
                     regeditKeyNames = key.GetValueNames();
                     ///遍历键值集合，如果存在键值，则退出遍历               
                     foreach (string regeditKey in regeditKeyNames)
                     {
                         if (string.Compare(regeditKey, name, true) == 0)
                         {
                             result = true;
                             break;
                         }
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return result;
             }
             #endregion

             #region 设置键值内容
             /// <summary>              
             /// 设置指定的键值内容，不指定内容数据类型（请先设置RegeditKey和SubKey属性）              
             /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容              
             /// </summary>              
             /// <param name=""content"">键值内容</param> 
             /// <returns>键值内容设置成功，则返回true，否则返回false</returns>              
             public virtual bool WriteRegeditKey(object content)
             {
                 ///返回结果               
                 bool result = false;

                 ///判断是否设置键值属性               
                 if (_regeditkey == string.Empty || _regeditkey == null)
                 {
                     return false;
                 }

                 ///判断注册表项是否存在，如果不存在，则直接创建               
                 if (!IsSubKeyExist(_subkey))
                 {
                     CreateSubKey(_subkey);
                 }

                 ///以可写方式打开注册表项               
                 RegistryKey key = OpenSubKey(true);

                 ///如果注册表项打开失败，则返回false               
                 if (key == null)
                 {
                     return false;
                 }

                 try
                 {
                     key.SetValue(_regeditkey, content);
                     result = true;
                 }
                 catch
                 {
                     result = false;
                 }
                 finally
                 {
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return result;
             }

             /// <summary>              
             /// 设置指定的键值内容，不指定内容数据类型（请先设置SubKey属性）              
             /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <param name=""content"">键值内容</param> 
             /// <returns>键值内容设置成功，则返回true，否则返回false</returns>              
             public virtual bool WriteRegeditKey(string name, object content)
             {
                 ///返回结果               
                 bool result = false;

                 ///判断键值是否存在               
                 if (name == string.Empty || name == null)
                 {
                     return false;
                 }

                 ///判断注册表项是否存在，如果不存在，则直接创建               
                 if (!IsSubKeyExist(_subkey))
                 {
                     CreateSubKey(_subkey);
                 }

                 ///以可写方式打开注册表项               
                 RegistryKey key = OpenSubKey(true);

                 ///如果注册表项打开失败，则返回false               
                 if (key == null)
                 {
                     return false;
                 }

                 try
                 {
                     key.SetValue(name, content);
                     result = true;
                 }
                 catch (Exception ex)
                 {
                     Debug.WriteLine(ex.Message);
                     result = false;
                 }
                 finally
                 {
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return result;
             }

             /// <summary>              
             /// 设置指定的键值内容，指定内容数据类型（请先设置SubKey属性）              
             /// 存在改键值则修改键值内容，不存在键值则先创建键值，再设置键值内容              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <param name=""content"">键值内容</param> 
             /// <returns>键值内容设置成功，则返回true，否则返回false</returns>              
             public virtual bool WriteRegeditKey(string name, object content, RegValueKind regValueKind)
             {
                 ///返回结果               
                 bool result = false;

                 ///判断键值是否存在               
                 if (name == string.Empty || name == null)
                 {
                     return false;
                 }

                 ///判断注册表项是否存在，如果不存在，则直接创建               
                 if (!IsSubKeyExist(_subkey))
                 {
                     CreateSubKey(_subkey);
                 }

                 ///以可写方式打开注册表项               
                 RegistryKey key = OpenSubKey(true);

                 ///如果注册表项打开失败，则返回false               
                 if (key == null)
                 {
                     return false;
                 }

                 try
                 {
                     key.SetValue(name, content, GetRegValueKind(regValueKind));
                     result = true;
                 }
                 catch
                 {
                     result = false;
                 }
                 finally
                 {
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return result;
             }
             #endregion

             #region 读取键值内容
             /// <summary>              
             /// 读取键值内容（请先设置RegeditKey和SubKey属性）              
             /// 1.如果RegeditKey为空、null或者RegeditKey指示的键值不存在，返回null              
             /// 2.如果SubKey为空、null或者SubKey指示的注册表项不存在，返回null              
             /// 3.反之，则返回键值内容              
             /// </summary>              
             /// <returns>返回键值内容</returns>              
             public virtual object ReadRegeditKey()
             {
                 ///键值内容结果               
                 object obj = null;

                 ///判断是否设置键值属性               
                 if (_regeditkey == string.Empty || _regeditkey == null)
                 {
                     return null;
                 }

                 ///判断键值是否存在               
                 if (IsRegeditKeyExist(_regeditkey))
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey();
                     if (key != null)
                     {
                         obj = key.GetValue(_regeditkey);
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return obj;
             }

             /// <summary>              
             /// 读取键值内容（请先设置SubKey属性）              
             /// 1.如果SubKey为空、null或者SubKey指示的注册表项不存在，返回null              
             /// 2.反之，则返回键值内容              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <returns>返回键值内容</returns>              
             public virtual object ReadRegeditKey(string name)
             {
                 ///键值内容结果               
                 object obj = null;

                 ///判断是否设置键值属性               
                 if (name == string.Empty || name == null)
                 {
                     return null;
                 }

                 ///判断键值是否存在               
                 if (IsRegeditKeyExist(name))
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey();
                     if (key != null)
                     {
                         obj = key.GetValue(name);
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return obj;
             }

             /// <summary>              
             /// 读取键值内容              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <param name=""subKey"">注册表项名称</param> 
             /// <returns>返回键值内容</returns>              
             public virtual object ReadRegeditKey(string name, string subKey)
             {
                 ///键值内容结果               
                 object obj = null;

                 ///判断是否设置键值属性               
                 if (name == string.Empty || name == null)
                 {
                     return null;
                 }

                 ///判断键值是否存在               
                 if (IsRegeditKeyExist(name))
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey(subKey);
                     if (key != null)
                     {
                         obj = key.GetValue(name);
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return obj;
             }

             /// <summary>              
             /// 读取键值内容              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>返回键值内容</returns>              
             public virtual object ReadRegeditKey(string name, string subKey, RegDomain regDomain)
             {
                 ///键值内容结果               
                 object obj = null;

                 ///判断是否设置键值属性               
                 if (name == string.Empty || name == null)
                 {
                     return null;
                 }

                 ///判断键值是否存在               
                 if (IsRegeditKeyExist(name))
                 {
                     ///打开注册表项               
                     RegistryKey key = OpenSubKey(subKey, regDomain);
                     if (key != null)
                     {
                         obj = key.GetValue(name);
                     }
                     ///关闭对注册表项的更改               
                     key.Close();
                 }
                 return obj;
             }
             #endregion

             #region 删除键值
             /// <summary>              
             /// 删除键值（请先设置RegeditKey和SubKey属性）              
             /// 1.如果RegeditKey为空、null或者RegeditKey指示的键值不存在，返回false              
             /// 2.如果SubKey为空、null或者SubKey指示的注册表项不存在，返回false              
             /// </summary>              
             /// <returns>如果删除成功，返回true，否则返回false</returns>              
             public virtual bool DeleteRegeditKey()
             {
                 ///删除结果               
                 bool result = false;

                 ///判断是否设置键值属性，如果没有设置，则返回false               
                 if (_regeditkey == string.Empty || _regeditkey == null)
                 {
                     return false;
                 }

                 ///判断键值是否存在               
                 if (IsRegeditKeyExist(_regeditkey))
                 {
                     ///以可写方式打开注册表项               
                     RegistryKey key = OpenSubKey(true);
                     if (key != null)
                     {
                         try
                         {
                             ///删除键值               
                             key.DeleteValue(_regeditkey);
                             result = true;
                         }
                         catch
                         {
                             result = false;
                         }
                         finally
                         {
                             ///关闭对注册表项的更改               
                             key.Close();
                         }
                     }
                 }

                 return result;
             }

             /// <summary>              
             /// 删除键值（请先设置SubKey属性）              
             /// 如果SubKey为空、null或者SubKey指示的注册表项不存在，返回false              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <returns>如果删除成功，返回true，否则返回false</returns>              
             public virtual bool DeleteRegeditKey(string name)
             {
                 ///删除结果               
                 bool result = false;

                 ///判断键值名称是否为空，如果为空，则返回false               
                 if (name == string.Empty || name == null)
                 {
                     return false;
                 }

                 ///判断键值是否存在               
                 if (IsRegeditKeyExist(name))
                 {
                     ///以可写方式打开注册表项               
                     RegistryKey key = OpenSubKey(true);
                     if (key != null)
                     {
                         try
                         {
                             ///删除键值               
                             key.DeleteValue(name);
                             result = true;
                         }
                         catch
                         {
                             result = false;
                         }
                         finally
                         {
                             ///关闭对注册表项的更改               
                             key.Close();
                         }
                     }
                 }

                 return result;
             }

             /// <summary>              
             /// 删除键值              
             /// </summary>              
             /// <param name=""name"">键值名称</param> 
             /// <param name=""subKey"">注册表项名称</param> 
             /// <returns>如果删除成功，返回true，否则返回false</returns>              
             public virtual bool DeleteRegeditKey(string name, string subKey)
             {
                 ///删除结果               
                 bool result = false;

                 ///判断键值名称和注册表项名称是否为空，如果为空，则返回false               
                 if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)
                 {
                     return false;
                 }

                 ///判断键值是否存在               
                 if (IsRegeditKeyExist(name))
                 {
                     ///以可写方式打开注册表项               
                     RegistryKey key = OpenSubKey(subKey, true);
                     if (key != null)
                     {
                         try
                         {
                             ///删除键值               
                             key.DeleteValue(name);
                             result = true;
                         }
                         catch
                         {
                             result = false;
                         }
                         finally
                         {
                             ///关闭对注册表项的更改               
                             key.Close();
                         }
                     }
                 }

                 return result;
             }

             /// <summary>               
             /// 删除键值               
             /// </summary>               
             /// <param name=""name"">键值名称</param> 
             /// <param name=""subKey"">注册表项名称</param> 
             /// <param name=""regDomain"">注册表基项域</param> 
             /// <returns>如果删除成功，返回true，否则返回false</returns>               
             public virtual bool DeleteRegeditKey(string name, string subKey, RegDomain regDomain)
             {
                 ///删除结果                
                 bool result = false;

                 ///判断键值名称和注册表项名称是否为空，如果为空，则返回false                
                 if (name == string.Empty || name == null || subKey == string.Empty || subKey == null)
                 {
                     return false;
                 }

                 ///判断键值是否存在                
                 if (IsRegeditKeyExist(name))
                 {
                     ///以可写方式打开注册表项                
                     RegistryKey key = OpenSubKey(subKey, regDomain, true);
                     if (key != null)
                     {
                         try
                         {
                             ///删除键值                
                             key.DeleteValue(name);
                             result = true;
                         }
                         catch
                         {
                             result = false;
                         }
                         finally
                         {
                             ///关闭对注册表项的更改                
                             key.Close();
                         }
                     }
                 }

                 return result;
             }
             #endregion
             #endregion
         } 
        #endregion
}
